home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Graphics / MapMaker / Source / ControlObject.m < prev    next >
Encoding:
Text File  |  1990-12-08  |  9.4 KB  |  631 lines
  1.  
  2. /* Generated by Interface Builder */
  3.  
  4. #import "ControlObject.h"
  5. #import "InputView.h"
  6. #import "OutputView.h"
  7. #import "constants.h"
  8. #import "pointdata.h"
  9. #import "proj.h"
  10. #import "fractal.h"
  11. #import <appkit/appkit.h>
  12. #import <math.h>
  13.  
  14. int started = 0;
  15.  
  16. float roundToNearestDivisible(float f)
  17. {
  18.     int g,b,l;
  19.     
  20.     if (f<MINROT) {
  21.         f = MINROT;
  22.         return f;
  23.     }
  24.     if (f>MAXROT) {
  25.         f = MAXROT;
  26.         return f;
  27.     }
  28.     
  29.     for(g = round(f);      ((360%g) && (g<=MAXROT));   g++)
  30.     for(l = round(f);    ((360%l) && (l>= MINROT));  l--);
  31.     
  32.     if (l< MINROT)
  33.         l = MINROT;
  34.     if (g> MAXROT)
  35.         g = MAXROT;
  36.         
  37.     if ((fabs(g-round(f))) < fabs((round(f)-l)))
  38.         return (float)g;
  39.     else
  40.         return (float)l;
  41. }
  42.  
  43. float normalize(float p)
  44. {
  45.     int mult;
  46.     int rem;
  47.     mult = (round(p))/180;
  48.     rem = ((int)(round(p)))%180;
  49.     if (mult%2)
  50.         return (-180 + (p-(180*mult)));
  51.     else
  52.         return  p-(180*mult);
  53. }
  54.  
  55. @implementation ControlObject
  56.  
  57. - setIView:anObject
  58. {
  59.     iView = anObject;
  60.     return self;
  61. }
  62.  
  63. - setGridCell:anObject
  64. {
  65.     gridCell = anObject;
  66.     return self;
  67. }
  68.  
  69. - setGridCell2:anObject
  70. {
  71.     gridCell2 = anObject;
  72.     return self;
  73. }
  74.  
  75. - setOView:anObject
  76. {
  77.     oView = anObject;
  78.     return self;
  79. }
  80.  
  81. - setProjType:anObject
  82. {
  83.     projType = anObject;
  84.     return self;
  85. }
  86.  
  87. -setElevationfield:anObject
  88. {
  89.     elevationfield = anObject;
  90.     return self;
  91. }
  92.  
  93. - setSlider:anObject
  94.  {
  95.      slider = anObject;
  96.      return self;
  97.  }
  98.  
  99. - setStep:anObject
  100. {
  101.     step = anObject;
  102.     return self;
  103. }
  104.  
  105. - setBbplay:anObject
  106. {
  107.     bbplay = anObject;
  108.     return self;
  109. }
  110.  
  111. - setBplay:anObject
  112. {
  113.     bplay = anObject;
  114.     return self;
  115. }
  116.  
  117. - setStop:anObject
  118. {
  119.     stop = anObject;
  120.     return self;
  121. }
  122.  
  123. - setFplay:anObject
  124. {
  125.     fplay = anObject;
  126.     return self;
  127. }
  128.  
  129. - setFfplay:anObject
  130. {
  131.     ffplay = anObject;
  132.     return self;
  133. }
  134.  
  135. - setProjectionMatrix:anObject
  136. {
  137.     projectionMatrix = anObject;
  138.     return self;
  139. }
  140.  
  141. - setScaleField:anObject
  142. {
  143.     scaleField = anObject;
  144.     return self;
  145. }
  146.  
  147. - setRotationField:anObject
  148. {
  149.     rotationField = anObject;
  150.     return self;
  151. }
  152.  
  153. - setAlertWindow:anObject
  154. {
  155.     alertWindow = anObject;
  156.     return self;
  157. }
  158.  
  159. - setAlertText:anObject
  160. {
  161.     alertText = anObject;
  162.     return self;
  163. }
  164.  
  165. - setHValueField:anObject
  166. {
  167.     hValueField = anObject;
  168.     return self;
  169. }
  170.  
  171. - setStDevField:anObject
  172. {
  173.     stDevField = anObject;
  174.     return self;
  175. }
  176.  
  177. - setFractStateButton:anObject
  178. {
  179.     fractStateButton = anObject;
  180.     return self;
  181. }
  182.  
  183. - setTimeSliceField:anObject
  184. {
  185.     timeSliceField = anObject;
  186.     return self;
  187. }
  188.  
  189. - setRateSlider:anObject
  190. {
  191.     rateSlider = anObject;
  192.     return self;
  193. }
  194.  
  195. - setInputMode:anObject
  196. {
  197.     inputMode = anObject;
  198.     return self;
  199. }
  200.  
  201. - setInputX:anObject
  202. {
  203.     inputX = anObject;
  204.     return self;
  205. }
  206.  
  207. - setInputY:anObject
  208. {
  209.     inputY = anObject;
  210.     return self;
  211. }
  212.  
  213. - setInputPen:anObject
  214. {
  215.     inputPen = anObject;
  216.     return self;
  217. }
  218.  
  219. - saveiView:sender
  220. {
  221.     [iView saveFile];
  222.     return self;
  223. }
  224.  
  225. - openiView:sender
  226. {
  227.     [iView openFile];
  228.     return self;
  229. }
  230.  
  231. - newiView:sender
  232. {
  233.     [iView clearFile];
  234.     return self;
  235. }
  236.  
  237. - gridStateChanged:sender
  238. {
  239.     BOOL oldGridState;
  240.     
  241.     oldGridState = [iView gridState];
  242.     if (oldGridState==YES) {
  243.         [gridCell setTitle:"Set Grid On"];
  244.         [iView setGridState:NO];
  245.     } else {
  246.         [gridCell setTitle:"Set Grid Off"];
  247.         [iView setGridState:YES];
  248.     }
  249.     [[iView window] display];
  250.     return self;
  251. }
  252.  
  253. - gridStateChanged2:sender
  254. {
  255.     BOOL oldGridState;
  256.     
  257.     oldGridState = [oView gridState];
  258.     if (oldGridState==YES) {
  259.         [gridCell2 setTitle:"Set Grid On"];
  260.         [oView setGridState:NO];
  261.     } else {
  262.         [gridCell2 setTitle:"Set Grid Off"];
  263.         [oView setGridState:YES];
  264.     }
  265.     if (!animation)
  266.         [self refreshOutput];
  267.     return self;
  268. }
  269.  
  270. - start
  271. {
  272.     float f;
  273.  
  274.     started = 1;
  275.     [iView setGridState:YES];
  276.     [iView setItUp:self];
  277.     [[iView window] display];
  278.     
  279.     [timeSliceField setFloatValue:[rateSlider floatValue]];
  280.     
  281.     [oView setGridState:YES];
  282.     [oView setItUp:self];
  283.     [oView rateChanged:[timeSliceField floatValue]];
  284.     [[oView window] display];
  285.  
  286.     force = 1;
  287.     [stop setEnabled:NO];
  288.     pparam.radius = [scaleField floatValue];
  289.     f= [elevationfield floatValue];
  290.     if ((f<(-90.0)) || (f>90.0)) {
  291.         [elevationfield setFloatValue:0.0];
  292.         [slider setFloatValue:0.0];
  293.         pparam.phi1 = 0.0;
  294.     }
  295.     else {
  296.         [slider setFloatValue:f];
  297.         pparam.phi1 = (f/180) * PI;
  298.     }
  299.     f = normalize([rotationField floatValue]);
  300.     [rotationField setFloatValue:f];
  301.     pparam.lon0 = ((f/180) * PI);
  302.     pparam.proj = [[projType selectedCell] tag];
  303.     animation = STOPPED;
  304.  
  305.     [self getNewInput];
  306.     [self refreshOutput];
  307.     return self;
  308. }
  309.  
  310. - appDidInit:sender
  311. {
  312.     /* This part gets around the fact that if a document is opened, the "open" program */
  313.     /*    will call appOpenFile before appDidInit.*/
  314.     if (!started)
  315.         [self start];
  316. }
  317.  
  318. - (BOOL)appAcceptsAnotherFile:(id)sender 
  319. {
  320.     return YES;
  321. }
  322.  
  323. - (int)appOpenFile:(const char *)filename type:(const char *)aType
  324. {
  325.     if (!started)
  326.         [self start];
  327.     [iView openFile:filename];
  328.     return 1;
  329. }
  330.  
  331. - rotationFieldChanged:sender
  332. {
  333.     float f;
  334.     f = normalize([sender floatValue]);
  335.     [sender setFloatValue:f];
  336.     if (!animation)
  337.         [self refreshOutput];
  338.     return self;
  339. }
  340.  
  341. - scaleFieldChanged:sender
  342. {
  343.     pparam.radius = [sender floatValue];
  344.     if (!animation)
  345.         [self refreshOutput];
  346.     return self;
  347. }
  348.  
  349. - elevationfieldchanged:sender
  350. {
  351.     float f;
  352.     
  353.     f= [sender floatValue];
  354.     if ((f<(-90.0)) || (f>90.0)) {
  355.         [sender setFloatValue:[slider floatValue]];
  356.         f = [slider floatValue];
  357.     }
  358.     else {
  359.         [slider setFloatValue:f];
  360.         [sender setFloatValue:f];
  361.         pparam.phi1 = (f/180) * PI;
  362.     }
  363.     if (!animation)
  364.         [self refreshOutput];
  365.     return self;
  366. }
  367.  
  368. - slidermoved:sender
  369. {
  370.     float f;
  371.     
  372.     f= [sender floatValue];
  373.     [elevationfield setFloatValue:f];
  374.     pparam.phi1 = (f/180) * PI;
  375.     if (!animation)
  376.         [self refreshOutput];
  377.     return self;
  378. }
  379.  
  380. - stepChanged:sender
  381. {
  382.     float f;
  383.     
  384.     f = [sender floatValue];
  385.     pparam.lon0 = ((f/180)*PI);
  386.     if (!animation)
  387.         [self refreshOutput];
  388.     return self;
  389. }
  390.  
  391. - projChanged:sender
  392. {
  393.     pparam.proj = [[sender selectedCell] tag];
  394.     if (!animation)
  395.         [self refreshOutput];
  396.     return self;
  397. }
  398.  
  399. - disableControls
  400. {
  401.     [bbplay setEnabled:NO];
  402.     [bplay setEnabled:NO];
  403.     [stop setEnabled:YES];
  404.     [fplay setEnabled:NO];
  405.     [ffplay setEnabled:NO];
  406.     
  407.  
  408.     [projType setEnabled:NO];
  409.     [slider setEnabled:NO];
  410.     [elevationfield setEnabled:NO];
  411.     [scaleField setEnabled:NO];
  412.     [rotationField setEnabled:NO];
  413.     [step setEnabled:NO];
  414.     return self;
  415. }
  416.  
  417. - enableControls
  418. {
  419.     [bbplay setEnabled:YES];
  420.     [bplay setEnabled:YES];
  421.     [stop setEnabled:NO];
  422.     [fplay setEnabled:YES];
  423.     [ffplay setEnabled:YES];
  424.  
  425.     [projType setEnabled:YES];
  426.     [slider setEnabled:YES];
  427.     [elevationfield setEnabled:YES];
  428.     [scaleField setEnabled:YES];
  429.     [rotationField setEnabled:YES];
  430.     [step setEnabled:YES];
  431.     return self;
  432. }
  433.  
  434. - bbplayed:sender
  435. {
  436.     float f;
  437.     [stop setEnabled:NO];
  438.     f = [rotationField floatValue];
  439.     [rotationField setFloatValue:(normalize(f+[step floatValue]))];
  440.     [self refreshOutput];
  441.     return self;
  442. }
  443.  
  444. - bplayed:sender
  445. {
  446.     float f;
  447.     
  448.     [self disableControls];
  449.     f = [step floatValue];
  450.     f = roundToNearestDivisible(f);
  451.     [step setFloatValue:f];
  452.  
  453.     animation = BACKWARD;
  454.     [self refreshOutput];
  455.     return self;
  456. }
  457.  
  458. - stopped:sender
  459. {
  460.     [self enableControls];
  461.     animation = STOPPED;
  462.     [self refreshOutput];
  463.     return self;
  464. }
  465.  
  466. - fplayed:sender
  467. {
  468.     float f;
  469.     
  470.     [self disableControls];
  471.     f = [step floatValue];
  472.     f = roundToNearestDivisible(f);
  473.     [step setFloatValue:f];
  474.  
  475.     animation = FORWARD;
  476.     [self refreshOutput];
  477.     return self;
  478. }
  479.  
  480. - ffplayed:sender
  481. {
  482.     float f;
  483.     [stop setEnabled:YES];
  484.     f = [rotationField floatValue];
  485.     [rotationField setFloatValue:(normalize(f-[step floatValue]))];
  486.     [self refreshOutput];
  487.     return self;
  488. }
  489.  
  490. - getNewInput
  491. {
  492.     PointList *inList;
  493.     
  494.     if (segList.quantity)
  495.         freePointList(&segList);
  496.     newPointList(&segList);
  497.     [iView map:&inList];
  498.     setFValues([fractStateButton state],[hValueField floatValue],[stDevField floatValue]);
  499.     insertFSegments(inList,&segList,&pparam);
  500.     force = 1;
  501.     return self;
  502. }
  503.  
  504. - refreshOutput
  505. {
  506.     float f;
  507.  
  508.     pparam.lon0 = (([rotationField floatValue]/180) * PI);
  509.     pparam.phi1 = ([elevationfield floatValue]/180)*PI;
  510.     
  511.     if (animation) {
  512.         [oView setupAnimation:&pparam :[step floatValue] :&segList :force];
  513.         if (force) force = 0;
  514.         [oView startAnimating:animation];
  515.     } else {
  516.         if ([oView animation]) {
  517.             [oView stopAnimating:&f];
  518.             [rotationField setFloatValue:round(normalize(f))];
  519.             pparam.lon0 = (([rotationField floatValue]/180) * PI);
  520.         }
  521.         [oView doStill:&pparam:&segList];
  522.     }
  523.     
  524.     return self;
  525. }
  526.  
  527. - alertWindow
  528. {
  529.     return alertWindow;
  530. }
  531.  
  532. - alertText
  533. {
  534.     return alertText;
  535. }
  536.  
  537. - inputMode
  538. {
  539.     return inputMode;
  540. }
  541.  
  542. - inputX
  543. {
  544.     return inputX;
  545. }
  546.  
  547. - inputY
  548. {
  549.     return inputY;
  550. }
  551.  
  552. - inputPen
  553. {
  554.     return inputPen;
  555. }
  556.  
  557. - hValueChanged:sender
  558. {
  559.     float f;
  560.     f = [sender floatValue];
  561.     if (f  < 0.0)
  562.         [sender setFloatValue:0.0];
  563.     else if (f > 1.0)
  564.         [sender setFloatValue:1.0];
  565.     [self getNewInput];
  566.     [self refreshOutput];
  567.     return self;
  568. }
  569.  
  570. - stDevChanged:sender
  571. {
  572.     float f;
  573.     f = [sender floatValue];
  574.     if (f  < 0.0)
  575.         [sender setFloatValue:0.0];
  576.     else if (f > 1.0)
  577.         [sender setFloatValue:1.0];
  578.     [self getNewInput];
  579.     [self refreshOutput];
  580.     return self;
  581. }
  582.  
  583. - fractalStateChanged:sender
  584. {
  585.     [self getNewInput];
  586.     [self refreshOutput];
  587.     return self;
  588. }
  589.  
  590. - timeSliceChanged:sender
  591. {
  592.     float f;
  593.     f = [sender floatValue];
  594.     if (f < [rateSlider minValue])
  595.         f = [rateSlider minValue];
  596.     else if (f > 0.5)
  597.         f = [rateSlider maxValue];
  598.     [timeSliceField setFloatValue:f];
  599.     [rateSlider setFloatValue:f];
  600.     [oView rateChanged:f];
  601.     return self;
  602. }
  603.  
  604. - rateSliderChanged:sender
  605. {
  606.     float f;
  607.     f = [sender floatValue];
  608.     if (f < [rateSlider minValue])
  609.         f = [rateSlider minValue];
  610.     else if (f > [rateSlider maxValue])
  611.         f = [rateSlider maxValue];
  612.     [timeSliceField setFloatValue:f];
  613.     [rateSlider setFloatValue:f];
  614.     [oView rateChanged:f];
  615.     return self;
  616. }
  617.  
  618. - printOutput:sender
  619. {
  620.     [oView doPrint:&pparam:&segList];
  621.     return self;
  622. }
  623.  
  624. - mapIt:sender
  625. {
  626.     [self getNewInput];
  627.     [self refreshOutput];
  628.     return self;
  629. }
  630. @end
  631.